home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Freeware / Adobe Air 1.5 / AdobeAIRInstaller.exe / setup.swf / scripts / mx / controls / scrollClasses / ScrollBar.as next >
Encoding:
Text File  |  2008-10-29  |  24.2 KB  |  643 lines
  1. package mx.controls.scrollClasses
  2. {
  3.    import flash.events.Event;
  4.    import flash.events.MouseEvent;
  5.    import flash.events.TimerEvent;
  6.    import flash.geom.Point;
  7.    import flash.ui.Keyboard;
  8.    import flash.utils.Timer;
  9.    import mx.controls.Button;
  10.    import mx.core.FlexVersion;
  11.    import mx.core.UIComponent;
  12.    import mx.core.mx_internal;
  13.    import mx.events.FlexEvent;
  14.    import mx.events.ScrollEvent;
  15.    import mx.events.ScrollEventDetail;
  16.    import mx.styles.ISimpleStyleClient;
  17.    import mx.styles.StyleProxy;
  18.    
  19.    use namespace mx_internal;
  20.    
  21.    public class ScrollBar extends UIComponent
  22.    {
  23.       mx_internal static const VERSION:String = "3.0.0.0";
  24.       
  25.       public static const THICKNESS:Number = 16;
  26.       
  27.       private var _direction:String = "vertical";
  28.       
  29.       private var _pageScrollSize:Number = 0;
  30.       
  31.       mx_internal var scrollTrack:Button;
  32.       
  33.       mx_internal var downArrow:Button;
  34.       
  35.       mx_internal var scrollThumb:ScrollThumb;
  36.       
  37.       private var trackScrollRepeatDirection:int;
  38.       
  39.       private var _minScrollPosition:Number = 0;
  40.       
  41.       private var trackPosition:Number;
  42.       
  43.       private var _pageSize:Number = 0;
  44.       
  45.       mx_internal var _minHeight:Number = 32;
  46.       
  47.       private var _maxScrollPosition:Number = 0;
  48.       
  49.       private var trackScrollTimer:Timer;
  50.       
  51.       mx_internal var upArrow:Button;
  52.       
  53.       private var _lineScrollSize:Number = 1;
  54.       
  55.       private var _scrollPosition:Number = 0;
  56.       
  57.       private var trackScrolling:Boolean = false;
  58.       
  59.       mx_internal var isScrolling:Boolean;
  60.       
  61.       mx_internal var oldPosition:Number;
  62.       
  63.       mx_internal var _minWidth:Number = 16;
  64.       
  65.       public function ScrollBar()
  66.       {
  67.          super();
  68.       }
  69.       
  70.       override public function set enabled(param1:Boolean) : void
  71.       {
  72.          super.enabled = param1;
  73.          invalidateDisplayList();
  74.       }
  75.       
  76.       public function set lineScrollSize(param1:Number) : void
  77.       {
  78.          _lineScrollSize = param1;
  79.       }
  80.       
  81.       public function get minScrollPosition() : Number
  82.       {
  83.          return _minScrollPosition;
  84.       }
  85.       
  86.       mx_internal function dispatchScrollEvent(param1:Number, param2:String) : void
  87.       {
  88.          var _loc3_:ScrollEvent = new ScrollEvent(ScrollEvent.SCROLL);
  89.          _loc3_.detail = param2;
  90.          _loc3_.position = scrollPosition;
  91.          _loc3_.delta = scrollPosition - param1;
  92.          _loc3_.direction = direction;
  93.          dispatchEvent(_loc3_);
  94.       }
  95.       
  96.       private function downArrow_buttonDownHandler(param1:FlexEvent) : void
  97.       {
  98.          if(isNaN(mx_internal::oldPosition))
  99.          {
  100.             mx_internal::oldPosition = scrollPosition;
  101.          }
  102.          mx_internal::lineScroll(1);
  103.       }
  104.       
  105.       private function scrollTrack_mouseDownHandler(param1:MouseEvent) : void
  106.       {
  107.          if(!(param1.target == this || param1.target == mx_internal::scrollTrack))
  108.          {
  109.             return;
  110.          }
  111.          trackScrolling = true;
  112.          systemManager.addEventListener(MouseEvent.MOUSE_UP,scrollTrack_mouseUpHandler,true);
  113.          systemManager.addEventListener(MouseEvent.MOUSE_MOVE,scrollTrack_mouseMoveHandler,true);
  114.          systemManager.stage.addEventListener(MouseEvent.MOUSE_MOVE,stage_scrollTrack_mouseMoveHandler);
  115.          systemManager.stage.addEventListener(Event.MOUSE_LEAVE,scrollTrack_mouseLeaveHandler);
  116.          var _loc2_:Point = new Point(param1.localX,param1.localY);
  117.          _loc2_ = param1.target.localToGlobal(_loc2_);
  118.          _loc2_ = globalToLocal(_loc2_);
  119.          trackPosition = _loc2_.y;
  120.          if(isNaN(mx_internal::oldPosition))
  121.          {
  122.             mx_internal::oldPosition = scrollPosition;
  123.          }
  124.          trackScrollRepeatDirection = mx_internal::scrollThumb.y + mx_internal::scrollThumb.height < _loc2_.y ? 1 : (mx_internal::scrollThumb.y > _loc2_.y ? -1 : 0);
  125.          mx_internal::pageScroll(trackScrollRepeatDirection);
  126.          if(!trackScrollTimer)
  127.          {
  128.             trackScrollTimer = new Timer(getStyle("repeatDelay"),1);
  129.             trackScrollTimer.addEventListener(TimerEvent.TIMER,trackScrollTimerHandler);
  130.          }
  131.          trackScrollTimer.start();
  132.       }
  133.       
  134.       public function set minScrollPosition(param1:Number) : void
  135.       {
  136.          _minScrollPosition = param1;
  137.       }
  138.       
  139.       public function get scrollPosition() : Number
  140.       {
  141.          return _scrollPosition;
  142.       }
  143.       
  144.       mx_internal function get linePlusDetail() : String
  145.       {
  146.          return direction == ScrollBarDirection.VERTICAL ? ScrollEventDetail.LINE_DOWN : ScrollEventDetail.LINE_RIGHT;
  147.       }
  148.       
  149.       public function get maxScrollPosition() : Number
  150.       {
  151.          return _maxScrollPosition;
  152.       }
  153.       
  154.       protected function get thumbStyleFilters() : Object
  155.       {
  156.          return null;
  157.       }
  158.       
  159.       override public function set doubleClickEnabled(param1:Boolean) : void
  160.       {
  161.       }
  162.       
  163.       public function get lineScrollSize() : Number
  164.       {
  165.          return _lineScrollSize;
  166.       }
  167.       
  168.       private function stage_scrollTrack_mouseMoveHandler(param1:MouseEvent) : void
  169.       {
  170.          if(param1.target != stage)
  171.          {
  172.             return;
  173.          }
  174.          scrollTrack_mouseMoveHandler(param1);
  175.       }
  176.       
  177.       mx_internal function get virtualHeight() : Number
  178.       {
  179.          return unscaledHeight;
  180.       }
  181.       
  182.       public function set scrollPosition(param1:Number) : void
  183.       {
  184.          var _loc2_:Number = NaN;
  185.          var _loc3_:Number = NaN;
  186.          var _loc4_:Number = NaN;
  187.          _scrollPosition = param1;
  188.          if(mx_internal::scrollThumb)
  189.          {
  190.             if(!cacheAsBitmap)
  191.             {
  192.                cacheHeuristic = mx_internal::scrollThumb.cacheHeuristic = true;
  193.             }
  194.             if(!mx_internal::isScrolling)
  195.             {
  196.                param1 = Math.min(param1,maxScrollPosition);
  197.                param1 = Math.max(param1,minScrollPosition);
  198.                _loc2_ = maxScrollPosition - minScrollPosition;
  199.                _loc3_ = _loc2_ == 0 || isNaN(_loc2_) ? 0 : (param1 - minScrollPosition) * (trackHeight - mx_internal::scrollThumb.height) / _loc2_ + trackY;
  200.                _loc4_ = (mx_internal::virtualWidth - mx_internal::scrollThumb.width) / 2 + getStyle("thumbOffset");
  201.                mx_internal::scrollThumb.move(Math.round(_loc4_),Math.round(_loc3_));
  202.             }
  203.          }
  204.       }
  205.       
  206.       protected function get downArrowStyleFilters() : Object
  207.       {
  208.          return null;
  209.       }
  210.       
  211.       public function get pageSize() : Number
  212.       {
  213.          return _pageSize;
  214.       }
  215.       
  216.       public function set pageScrollSize(param1:Number) : void
  217.       {
  218.          _pageScrollSize = param1;
  219.       }
  220.       
  221.       public function set maxScrollPosition(param1:Number) : void
  222.       {
  223.          _maxScrollPosition = param1;
  224.       }
  225.       
  226.       mx_internal function pageScroll(param1:int) : void
  227.       {
  228.          var _loc4_:Number = NaN;
  229.          var _loc5_:String = null;
  230.          var _loc2_:Number = _pageScrollSize != 0 ? _pageScrollSize : pageSize;
  231.          var _loc3_:Number = _scrollPosition + param1 * _loc2_;
  232.          if(_loc3_ > maxScrollPosition)
  233.          {
  234.             _loc3_ = maxScrollPosition;
  235.          }
  236.          else if(_loc3_ < minScrollPosition)
  237.          {
  238.             _loc3_ = minScrollPosition;
  239.          }
  240.          if(_loc3_ != scrollPosition)
  241.          {
  242.             _loc4_ = scrollPosition;
  243.             scrollPosition = _loc3_;
  244.             _loc5_ = param1 < 0 ? mx_internal::pageMinusDetail : mx_internal::pagePlusDetail;
  245.             mx_internal::dispatchScrollEvent(_loc4_,_loc5_);
  246.          }
  247.       }
  248.       
  249.       override protected function createChildren() : void
  250.       {
  251.          super.createChildren();
  252.          if(!mx_internal::scrollTrack)
  253.          {
  254.             mx_internal::scrollTrack = new Button();
  255.             mx_internal::scrollTrack.focusEnabled = false;
  256.             mx_internal::scrollTrack.mx_internal::skinName = "trackSkin";
  257.             mx_internal::scrollTrack.mx_internal::upSkinName = "trackUpSkin";
  258.             mx_internal::scrollTrack.mx_internal::overSkinName = "trackOverSkin";
  259.             mx_internal::scrollTrack.mx_internal::downSkinName = "trackDownSkin";
  260.             mx_internal::scrollTrack.mx_internal::disabledSkinName = "trackDisabledSkin";
  261.             if(mx_internal::scrollTrack is ISimpleStyleClient)
  262.             {
  263.                ISimpleStyleClient(mx_internal::scrollTrack).styleName = this;
  264.             }
  265.             addChild(mx_internal::scrollTrack);
  266.             mx_internal::scrollTrack.validateProperties();
  267.          }
  268.          if(!mx_internal::upArrow)
  269.          {
  270.             mx_internal::upArrow = new Button();
  271.             mx_internal::upArrow.enabled = false;
  272.             mx_internal::upArrow.autoRepeat = true;
  273.             mx_internal::upArrow.focusEnabled = false;
  274.             mx_internal::upArrow.mx_internal::upSkinName = "upArrowUpSkin";
  275.             mx_internal::upArrow.mx_internal::overSkinName = "upArrowOverSkin";
  276.             mx_internal::upArrow.mx_internal::downSkinName = "upArrowDownSkin";
  277.             mx_internal::upArrow.mx_internal::disabledSkinName = "upArrowDisabledSkin";
  278.             mx_internal::upArrow.mx_internal::skinName = "upArrowSkin";
  279.             mx_internal::upArrow.mx_internal::upIconName = "";
  280.             mx_internal::upArrow.mx_internal::overIconName = "";
  281.             mx_internal::upArrow.mx_internal::downIconName = "";
  282.             mx_internal::upArrow.mx_internal::disabledIconName = "";
  283.             addChild(mx_internal::upArrow);
  284.             mx_internal::upArrow.styleName = new StyleProxy(this,upArrowStyleFilters);
  285.             mx_internal::upArrow.validateProperties();
  286.             mx_internal::upArrow.addEventListener(FlexEvent.BUTTON_DOWN,upArrow_buttonDownHandler);
  287.          }
  288.          if(!mx_internal::downArrow)
  289.          {
  290.             mx_internal::downArrow = new Button();
  291.             mx_internal::downArrow.enabled = false;
  292.             mx_internal::downArrow.autoRepeat = true;
  293.             mx_internal::downArrow.focusEnabled = false;
  294.             mx_internal::downArrow.mx_internal::upSkinName = "downArrowUpSkin";
  295.             mx_internal::downArrow.mx_internal::overSkinName = "downArrowOverSkin";
  296.             mx_internal::downArrow.mx_internal::downSkinName = "downArrowDownSkin";
  297.             mx_internal::downArrow.mx_internal::disabledSkinName = "downArrowDisabledSkin";
  298.             mx_internal::downArrow.mx_internal::skinName = "downArrowSkin";
  299.             mx_internal::downArrow.mx_internal::upIconName = "";
  300.             mx_internal::downArrow.mx_internal::overIconName = "";
  301.             mx_internal::downArrow.mx_internal::downIconName = "";
  302.             mx_internal::downArrow.mx_internal::disabledIconName = "";
  303.             addChild(mx_internal::downArrow);
  304.             mx_internal::downArrow.styleName = new StyleProxy(this,downArrowStyleFilters);
  305.             mx_internal::downArrow.validateProperties();
  306.             mx_internal::downArrow.addEventListener(FlexEvent.BUTTON_DOWN,downArrow_buttonDownHandler);
  307.          }
  308.       }
  309.       
  310.       private function scrollTrack_mouseOverHandler(param1:MouseEvent) : void
  311.       {
  312.          if(!(param1.target == this || param1.target == mx_internal::scrollTrack))
  313.          {
  314.             return;
  315.          }
  316.          if(trackScrolling)
  317.          {
  318.             trackScrollTimer.start();
  319.          }
  320.       }
  321.       
  322.       private function get minDetail() : String
  323.       {
  324.          return direction == ScrollBarDirection.VERTICAL ? ScrollEventDetail.AT_TOP : ScrollEventDetail.AT_LEFT;
  325.       }
  326.       
  327.       mx_internal function isScrollBarKey(param1:uint) : Boolean
  328.       {
  329.          var _loc2_:Number = NaN;
  330.          if(param1 == Keyboard.HOME)
  331.          {
  332.             if(scrollPosition != 0)
  333.             {
  334.                _loc2_ = scrollPosition;
  335.                scrollPosition = 0;
  336.                mx_internal::dispatchScrollEvent(_loc2_,minDetail);
  337.             }
  338.             return true;
  339.          }
  340.          if(param1 == Keyboard.END)
  341.          {
  342.             if(scrollPosition < maxScrollPosition)
  343.             {
  344.                _loc2_ = scrollPosition;
  345.                scrollPosition = maxScrollPosition;
  346.                mx_internal::dispatchScrollEvent(_loc2_,maxDetail);
  347.             }
  348.             return true;
  349.          }
  350.          return false;
  351.       }
  352.       
  353.       mx_internal function get lineMinusDetail() : String
  354.       {
  355.          return direction == ScrollBarDirection.VERTICAL ? ScrollEventDetail.LINE_UP : ScrollEventDetail.LINE_LEFT;
  356.       }
  357.       
  358.       mx_internal function get pageMinusDetail() : String
  359.       {
  360.          return direction == ScrollBarDirection.VERTICAL ? ScrollEventDetail.PAGE_UP : ScrollEventDetail.PAGE_LEFT;
  361.       }
  362.       
  363.       private function get maxDetail() : String
  364.       {
  365.          return direction == ScrollBarDirection.VERTICAL ? ScrollEventDetail.AT_BOTTOM : ScrollEventDetail.AT_RIGHT;
  366.       }
  367.       
  368.       private function scrollTrack_mouseLeaveHandler(param1:Event) : void
  369.       {
  370.          trackScrolling = false;
  371.          systemManager.removeEventListener(MouseEvent.MOUSE_UP,scrollTrack_mouseUpHandler,true);
  372.          systemManager.removeEventListener(MouseEvent.MOUSE_MOVE,scrollTrack_mouseMoveHandler,true);
  373.          systemManager.stage.removeEventListener(MouseEvent.MOUSE_MOVE,stage_scrollTrack_mouseMoveHandler);
  374.          systemManager.stage.removeEventListener(Event.MOUSE_LEAVE,scrollTrack_mouseLeaveHandler);
  375.          if(trackScrollTimer)
  376.          {
  377.             trackScrollTimer.reset();
  378.          }
  379.          if(param1.target != mx_internal::scrollTrack)
  380.          {
  381.             return;
  382.          }
  383.          var _loc2_:String = mx_internal::oldPosition > scrollPosition ? mx_internal::pageMinusDetail : mx_internal::pagePlusDetail;
  384.          mx_internal::dispatchScrollEvent(mx_internal::oldPosition,_loc2_);
  385.          mx_internal::oldPosition = NaN;
  386.       }
  387.       
  388.       protected function get upArrowStyleFilters() : Object
  389.       {
  390.          return null;
  391.       }
  392.       
  393.       private function get trackHeight() : Number
  394.       {
  395.          return mx_internal::virtualHeight - (mx_internal::upArrow.getExplicitOrMeasuredHeight() + mx_internal::downArrow.getExplicitOrMeasuredHeight());
  396.       }
  397.       
  398.       public function get pageScrollSize() : Number
  399.       {
  400.          return _pageScrollSize;
  401.       }
  402.       
  403.       override protected function measure() : void
  404.       {
  405.          super.measure();
  406.          mx_internal::upArrow.validateSize();
  407.          mx_internal::downArrow.validateSize();
  408.          mx_internal::scrollTrack.validateSize();
  409.          if(FlexVersion.compatibilityVersion >= FlexVersion.VERSION_3_0)
  410.          {
  411.             mx_internal::_minWidth = !!mx_internal::scrollThumb ? mx_internal::scrollThumb.getExplicitOrMeasuredWidth() : 0;
  412.             mx_internal::_minWidth = Math.max(mx_internal::scrollTrack.getExplicitOrMeasuredWidth(),mx_internal::upArrow.getExplicitOrMeasuredWidth(),mx_internal::downArrow.getExplicitOrMeasuredWidth(),mx_internal::_minWidth);
  413.          }
  414.          else
  415.          {
  416.             mx_internal::_minWidth = mx_internal::upArrow.getExplicitOrMeasuredWidth();
  417.          }
  418.          mx_internal::_minHeight = mx_internal::upArrow.getExplicitOrMeasuredHeight() + mx_internal::downArrow.getExplicitOrMeasuredHeight();
  419.       }
  420.       
  421.       mx_internal function lineScroll(param1:int) : void
  422.       {
  423.          var _loc4_:Number = NaN;
  424.          var _loc5_:String = null;
  425.          var _loc2_:Number = _lineScrollSize;
  426.          var _loc3_:Number = _scrollPosition + param1 * _loc2_;
  427.          if(_loc3_ > maxScrollPosition)
  428.          {
  429.             _loc3_ = maxScrollPosition;
  430.          }
  431.          else if(_loc3_ < minScrollPosition)
  432.          {
  433.             _loc3_ = minScrollPosition;
  434.          }
  435.          if(_loc3_ != scrollPosition)
  436.          {
  437.             _loc4_ = scrollPosition;
  438.             scrollPosition = _loc3_;
  439.             _loc5_ = param1 < 0 ? mx_internal::lineMinusDetail : mx_internal::linePlusDetail;
  440.             mx_internal::dispatchScrollEvent(_loc4_,_loc5_);
  441.          }
  442.       }
  443.       
  444.       public function setScrollProperties(param1:Number, param2:Number, param3:Number, param4:Number = 0) : void
  445.       {
  446.          var _loc5_:Number = NaN;
  447.          this.pageSize = param1;
  448.          _pageScrollSize = param4 > 0 ? param4 : param1;
  449.          this.minScrollPosition = Math.max(param2,0);
  450.          this.maxScrollPosition = Math.max(param3,0);
  451.          _scrollPosition = Math.max(this.minScrollPosition,_scrollPosition);
  452.          _scrollPosition = Math.min(this.maxScrollPosition,_scrollPosition);
  453.          if(this.maxScrollPosition - this.minScrollPosition > 0 && enabled)
  454.          {
  455.             mx_internal::upArrow.enabled = true;
  456.             mx_internal::downArrow.enabled = true;
  457.             mx_internal::scrollTrack.enabled = true;
  458.             addEventListener(MouseEvent.MOUSE_DOWN,scrollTrack_mouseDownHandler);
  459.             addEventListener(MouseEvent.MOUSE_OVER,scrollTrack_mouseOverHandler);
  460.             addEventListener(MouseEvent.MOUSE_OUT,scrollTrack_mouseOutHandler);
  461.             if(!mx_internal::scrollThumb)
  462.             {
  463.                mx_internal::scrollThumb = new ScrollThumb();
  464.                mx_internal::scrollThumb.focusEnabled = false;
  465.                addChildAt(mx_internal::scrollThumb,getChildIndex(mx_internal::downArrow));
  466.                mx_internal::scrollThumb.styleName = new StyleProxy(this,thumbStyleFilters);
  467.                mx_internal::scrollThumb.mx_internal::upSkinName = "thumbUpSkin";
  468.                mx_internal::scrollThumb.mx_internal::overSkinName = "thumbOverSkin";
  469.                mx_internal::scrollThumb.mx_internal::downSkinName = "thumbDownSkin";
  470.                mx_internal::scrollThumb.mx_internal::iconName = "thumbIcon";
  471.                mx_internal::scrollThumb.mx_internal::skinName = "thumbSkin";
  472.             }
  473.             _loc5_ = trackHeight < 0 ? 0 : Math.round(param1 / (this.maxScrollPosition - this.minScrollPosition + param1) * trackHeight);
  474.             if(_loc5_ < mx_internal::scrollThumb.minHeight)
  475.             {
  476.                if(trackHeight < mx_internal::scrollThumb.minHeight)
  477.                {
  478.                   mx_internal::scrollThumb.visible = false;
  479.                }
  480.                else
  481.                {
  482.                   _loc5_ = mx_internal::scrollThumb.minHeight;
  483.                   mx_internal::scrollThumb.visible = true;
  484.                   mx_internal::scrollThumb.setActualSize(mx_internal::scrollThumb.measuredWidth,mx_internal::scrollThumb.minHeight);
  485.                }
  486.             }
  487.             else
  488.             {
  489.                mx_internal::scrollThumb.visible = true;
  490.                mx_internal::scrollThumb.setActualSize(mx_internal::scrollThumb.measuredWidth,_loc5_);
  491.             }
  492.             mx_internal::scrollThumb.mx_internal::setRange(mx_internal::upArrow.getExplicitOrMeasuredHeight() + 0,mx_internal::virtualHeight - mx_internal::downArrow.getExplicitOrMeasuredHeight() - mx_internal::scrollThumb.height,this.minScrollPosition,this.maxScrollPosition);
  493.             scrollPosition = Math.max(Math.min(scrollPosition,this.maxScrollPosition),this.minScrollPosition);
  494.          }
  495.          else
  496.          {
  497.             mx_internal::upArrow.enabled = false;
  498.             mx_internal::downArrow.enabled = false;
  499.             mx_internal::scrollTrack.enabled = false;
  500.             if(mx_internal::scrollThumb)
  501.             {
  502.                mx_internal::scrollThumb.visible = false;
  503.             }
  504.          }
  505.       }
  506.       
  507.       private function trackScrollTimerHandler(param1:Event) : void
  508.       {
  509.          if(trackScrollRepeatDirection == 1)
  510.          {
  511.             if(mx_internal::scrollThumb.y + mx_internal::scrollThumb.height > trackPosition)
  512.             {
  513.                return;
  514.             }
  515.          }
  516.          if(trackScrollRepeatDirection == -1)
  517.          {
  518.             if(mx_internal::scrollThumb.y < trackPosition)
  519.             {
  520.                return;
  521.             }
  522.          }
  523.          mx_internal::pageScroll(trackScrollRepeatDirection);
  524.          if(Boolean(trackScrollTimer) && trackScrollTimer.repeatCount == 1)
  525.          {
  526.             trackScrollTimer.delay = getStyle("repeatInterval");
  527.             trackScrollTimer.repeatCount = 0;
  528.          }
  529.       }
  530.       
  531.       private function upArrow_buttonDownHandler(param1:FlexEvent) : void
  532.       {
  533.          if(isNaN(mx_internal::oldPosition))
  534.          {
  535.             mx_internal::oldPosition = scrollPosition;
  536.          }
  537.          mx_internal::lineScroll(-1);
  538.       }
  539.       
  540.       public function set pageSize(param1:Number) : void
  541.       {
  542.          _pageSize = param1;
  543.       }
  544.       
  545.       private function get trackY() : Number
  546.       {
  547.          return mx_internal::upArrow.getExplicitOrMeasuredHeight();
  548.       }
  549.       
  550.       private function scrollTrack_mouseOutHandler(param1:MouseEvent) : void
  551.       {
  552.          if(trackScrolling)
  553.          {
  554.             trackScrollTimer.stop();
  555.          }
  556.       }
  557.       
  558.       private function scrollTrack_mouseUpHandler(param1:MouseEvent) : void
  559.       {
  560.          scrollTrack_mouseLeaveHandler(param1);
  561.       }
  562.       
  563.       private function scrollTrack_mouseMoveHandler(param1:MouseEvent) : void
  564.       {
  565.          var _loc2_:Point = null;
  566.          if(trackScrolling)
  567.          {
  568.             _loc2_ = new Point(param1.stageX,param1.stageY);
  569.             _loc2_ = globalToLocal(_loc2_);
  570.             trackPosition = _loc2_.y;
  571.          }
  572.       }
  573.       
  574.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  575.       {
  576.          if(mx_internal::$height == 1)
  577.          {
  578.             return;
  579.          }
  580.          if(!mx_internal::upArrow)
  581.          {
  582.             return;
  583.          }
  584.          super.updateDisplayList(param1,param2);
  585.          if(cacheAsBitmap)
  586.          {
  587.             cacheHeuristic = mx_internal::scrollThumb.cacheHeuristic = false;
  588.          }
  589.          mx_internal::upArrow.setActualSize(mx_internal::upArrow.getExplicitOrMeasuredWidth(),mx_internal::upArrow.getExplicitOrMeasuredHeight());
  590.          if(FlexVersion.compatibilityVersion >= FlexVersion.VERSION_3_0)
  591.          {
  592.             mx_internal::upArrow.move((mx_internal::virtualWidth - mx_internal::upArrow.width) / 2,0);
  593.          }
  594.          else
  595.          {
  596.             mx_internal::upArrow.move(0,0);
  597.          }
  598.          mx_internal::scrollTrack.setActualSize(mx_internal::scrollTrack.getExplicitOrMeasuredWidth(),mx_internal::virtualHeight);
  599.          if(FlexVersion.compatibilityVersion >= FlexVersion.VERSION_3_0)
  600.          {
  601.             mx_internal::scrollTrack.x = (mx_internal::virtualWidth - mx_internal::scrollTrack.width) / 2;
  602.          }
  603.          mx_internal::scrollTrack.y = 0;
  604.          mx_internal::downArrow.setActualSize(mx_internal::downArrow.getExplicitOrMeasuredWidth(),mx_internal::downArrow.getExplicitOrMeasuredHeight());
  605.          if(FlexVersion.compatibilityVersion >= FlexVersion.VERSION_3_0)
  606.          {
  607.             mx_internal::downArrow.move((mx_internal::virtualWidth - mx_internal::downArrow.width) / 2,mx_internal::virtualHeight - mx_internal::downArrow.getExplicitOrMeasuredHeight());
  608.          }
  609.          else
  610.          {
  611.             mx_internal::downArrow.move(0,mx_internal::virtualHeight - mx_internal::downArrow.getExplicitOrMeasuredHeight());
  612.          }
  613.          setScrollProperties(pageSize,minScrollPosition,maxScrollPosition,_pageScrollSize);
  614.          scrollPosition = _scrollPosition;
  615.       }
  616.       
  617.       mx_internal function get pagePlusDetail() : String
  618.       {
  619.          return direction == ScrollBarDirection.VERTICAL ? ScrollEventDetail.PAGE_DOWN : ScrollEventDetail.PAGE_RIGHT;
  620.       }
  621.       
  622.       mx_internal function get virtualWidth() : Number
  623.       {
  624.          return unscaledWidth;
  625.       }
  626.       
  627.       public function set direction(param1:String) : void
  628.       {
  629.          _direction = param1;
  630.          invalidateSize();
  631.          invalidateDisplayList();
  632.          dispatchEvent(new Event("directionChanged"));
  633.       }
  634.       
  635.       [Bindable("directionChanged")]
  636.       public function get direction() : String
  637.       {
  638.          return _direction;
  639.       }
  640.    }
  641. }
  642.  
  643.